In an RRM approach used in the prior art, there are a plurality of RRM algorithms, each of which performs a different function and operates independently of the other RRM algorithms. Each algorithm has one or more associated triggers, and upon receiving a trigger, an algorithm executes to handle the trigger. The presently executing algorithm makes a decision to configure or reconfigure one of the radio links (RLs) or timeslots. Upon making the decision, the algorithm signals the new configuration throughout the entire system. FIG. 1 shows an example of algorithms and associated triggers operating independently according to the prior art approach. FIG. 2 shows an example of the algorithms in a controlling radio network controller (C-RNC) and a serving radio network controller (S-RNC) according to the prior art independent algorithm approach.
Individual RRM algorithms attempt to satisfy the request for one trigger for a specific timeslot or code, but do not consider other triggers and factors for the rest of the system. This leads to serious problems, because during the execution of the new configuration for one RL, the other triggers are ignored because an algorithm is busy trying to execute its own decision. This could lead to rejecting new service requests if the algorithm is busy solving a specific problem for a specific WTRU. Additionally, an RL can be torn down if there are other severe problems and they are ignored while the algorithm is trying to solve another problem.
Furthermore, two algorithms can act on the same problem at the same time. For example, in a C-RNC, the fast dynamic channel allocation (F-DCA) Escape procedure and the Slow Congestion Control procedure could be attempting to solve the problem of having a high uplink interference signal code power (ISCP) by taking different actions at the same time. A similar situation can exist in the S-RNC if, for example, the Outer Loop Power Control procedure is active and the Link Maintenance procedure is attempting to solve a Block Error Rate problem simultaneously. An even worse situation could exist, because an algorithm could reverse or conflict with the operation of a previously executed algorithm.
In this independent algorithm approach, multiple triggers cannot be processed as the same time. This could lead to rejecting a service request or a new call because another algorithm is busy fixing another problem for this RL.
The independent algorithm approach is not the optimal solution for the following reasons:
(1) There is no entity which coordinates between different algorithms. It is possible that two algorithms, working independently in parallel, could attempt to accomplish similar actions or even attempt to perform contradicting actions.
(2) Multiple triggers for various algorithms cannot be handled at the same time for a specific WTRU.
(3) New service requests for a given WTRU could be rejected if another algorithm is operating on this WTRU. This could have negative impact on the end user's perception of the system's operation.
(4) One measurement or event can trigger many algorithms. On the other hand, many measurements or events can trigger one algorithm. This multiple trigger/multiple response situation may cause conflicting actions to occur in the system.
(5) Different priorities cannot be assigned to different algorithms since there is no centralized entity to prioritize the algorithms.
(6) Measurement-based algorithms may base their decisions on measurements which are no longer valid, since another algorithm may be acting at the same time and changing the system conditions.
(7) There is a high level of signaling overhead involved in the independent algorithm approach.
(8) Some algorithms have been merged together to solve the interaction problems. But even after merging the algorithms, there are still some unsupported interaction scenarios.
(9) Some of the merged algorithms are run for real time (RT) calls only and other algorithms are run for non-real time (NRT) calls only. After merging the algorithms together, the individual algorithms do not necessarily have the knowledge of whether the call being processed is RT or NRT.
(10) In order to coordinate the independent algorithms with each other, each algorithm needs to be modified to include some coordination functionality. This functionality has to be spread across all of the algorithms, leading to redundant coding.
Accordingly, the decentralized approach of prior art RRM techniques does not provide optimum system performance.